# 1，简述线程和协程的异同?
# 进程是资源分配的最小单位,线程是CPU调度的最小单位，每一个进程中至少有一个线程。
# 协程也叫微线程，在单线程上执行多个任务，可由函数来进行任务的切换
# 2，什么是并行，什么是并发？
# 并行就是任务同时进行，如多核的cpu
# 并发就是多个任务轮流交替使用资源
# 3，请解释同步和异步这两个概念？
# 同步就是等待一个任务执行完成,再提交下一个任务
# 异步就是在一个任务遇到阻塞的时候去执行其他的任务
# 4，GIL锁是怎么回事?
# 基于Python解释器的全局解释器锁，保证同一时刻只能有一个线程访问cpu
# 5，什么叫死锁？如何产生？如何解决
# 多个线程或进程抢夺同一个资源造成互相等待的现象
# 6，写一个程序，利用queue实现进程间通信；
# from multiprocessing import Queue,Process
# def produce(q):
#     q.put('123')
#
# def consume(q):
#     print(q.get())
# if __name__ == '__main__':
#     q = Queue()
#     p = Process(target=produce,args=(q,))
#     p.start()
#     c = Process(target=consume, args=(q,))
#     c.start()
# 7，写一个程序，包含十个线程，同时只能有五个子线程并行执行
# import time
# from threading import Semaphore,Thread
# def func(sem,i):
#     sem.acquire()
#     time.sleep(1)
#     print(i)
#     sem.release()
# sem = Semaphore(5)
# for i in range(10):
#     t = Thread(target=func,args=(sem,i))
#     t.start()

# 8，写一个程序，线程C在线程B后执行，线程B在线程A之后进行
# import threading, time
# def a():
#     lock1.acquire()
#     print("is  A")
#     time.sleep(1)
#     lock3.release()
# def b():
#     lock2.acquire()
#     print("is  B")
#     time.sleep(1)
#     lock1.release()
# def c():
#     lock3.acquire()
#     print("is  C")
#     time.sleep(1)
#     lock2.release()
# if __name__ == "__main__":
#     lock1 = threading.Lock()
#     lock2 = threading.Lock()
#     lock3 = threading.Lock()
#     A = threading.Thread(target=a, )
#     B = threading.Thread(target=b, )
#     C = threading.Thread(target=c, )
#     A.start()
#     B.start()
#     C.start()
# 9，编写一个程序，开启3个线程，这3个线程的name分别为A、B、C，每个线程将自己的name在屏幕上打印10遍，要求输出结果必须按ABC的顺序显示；如：ABCABC….依次递推
# import threading, time
#
# s1 = threading.Semaphore(3)
#
#
# def aa():
#     print(threading.current_thread().name)
#
#
# for i in range(10):
#     t1 = threading.Thread(target=aa, name="A")
#     t2 = threading.Thread(target=aa, name="B")
#     t3 = threading.Thread(target=aa, name="C")
#     t1.start()
#     t2.start()
#     t3.start()
#     time.sleep(1)

# 10，简述生产者与消费者模式（用自己的话默写）

